type
  TCommonObject = class
  private
    FSomeCommonValue: integer;
  protected
    function GetSomeCommonValue: integer; virtual; abstract;
  published
    property SomeCommonProperty: integer read GetSomeCommonValue;
  end;
   
  TMyObject = class(TCommonObject)
  private
    FSomePrivateField: integer;
  protected
    function GetSomeCommonValue: integer; override;
    procedure SomeProtectedMethod(Param1: integer; const Param2: string; out OutParam: string); virtual;
    procedure SetSomeOtherProperty(Value: integer);
    function GetSomeOtherProperty: integer;
  public
    constructor Create;
    destructor Destroy; override;
    procedure SomePublicMethod;
  published
    property SomePublishedProperty: integer read FSomePrivateField; // readonly
    property SomeOtherProperty: integer read GetSomeOtherProperty write SetSomeOtherProperty;
  end;

Dieses Beispiel definiert die zwei Klassen TCommonObject und TMyObject. TCommonObject beschreibt eine abstrakte Klasse, zu deren Entwurfszeit noch nichts über die konkrete Implementierung der Methode GetSomeCommonValue bekannt ist. Jedoch kann es für die weitere Verarbeitung verschiedener Nachfahren von TCommonObject zwingend erforderlich sein, dass diese Methode vorhanden ist. TCommonObject enthält also all diejenigen Methoden und Merkmale, die allen Nachfahren gemein ist. Hier in dem Beispiel wird GetSomeCommonValue erst in der Klasse TMyObject, die sämtliche Methoden und Merkmale von TCommonObject erbt, konkret implementiert.

Wie in dem Beispiel zu erkennen, bestehen Klassen in Object Pascal aus höchstens vier Sichtbarkeitsbereichen, die man auch Sichtbarkeitsattribute bezeichnet: private, protected, public und published. Sämtliche zu private gehörenden Elemente sind ca. innerhalb des Objektes sichtbar. Selbst in direkten Nachfahren hat man keinen Zugriff auf diesen Bereich. protected bestimmt ebenfalls von außen nicht sichtbare Elemente, auf die man jedoch in Nachfahren zugreifen kann. Alles was in dem Bereich public definiert wird, unterliegt keiner Beschränkung. Hinzu kommt speziell in Delphi das published Attribut. published steuert die Sichtbarkeit in dem Object Inspector und bewirkt weitere Informationen für RTTI. Die Sichtbarkeit kann in Nachfahren durch Redeklaration erhöht, allerdings nicht verringert werden.

Properties dienen zu dem Information hiding , indem ein direkter Zugriff auf die Variable verhindert wird und die Methode entscheiden kann, welchen Wert sie beim Lesen herausgibt und beim Ändern eines Wertes akzeptiert, was einen ADT (abstract data type) auszeichnet. Wird beispielsweise wie bei property SomePublishedProperty keine write-Methode angegeben, so handelt es sich um eine read-only Variable.

constructor TMyObject.Create;
// legt eine Objectinstanz an
begin
  inherited;
  // Konstruktor der Oberklasse rufen
  fSomePrivateField := 42;
  // privates Feld mit 42 initialisieren
end;
 
destructor TMyObject.Destroy;
begin   
  inherited;
  // Destruktor der Oberklasse aufrufen
end;
 
function TMyObject.GetSomeCommonValue: integer;
begin
  Result := FSomeCommonValue*2
end;
 
procedure TMyObject.SomeProtectedMethod(Param1: integer; const Param2: string; out OutParam: string);
var
   i: integer;
   // Deklaration lokaler Variablen
begin
  OutParam := ;
  // Ausgabeparameter initialisieren
  for i:=1 to Param1 do
    OutParam := OutParam + Param2;
  // Ausgabeparameter mit dem Eingabeparameter Param1-mal konkatenieren
end;
 
procedure TMyObject.SomePublicMethod;
begin
  Inc(fSomePrivateField);
  // privates Feld hochzählen
end;
 
procedure SetSomeOtherProperty(Value: integer);
begin
  fSomePrivateField := Value * 5;
end;
 
function GetSomeOtherProperty: integer;
begin
  Result := fSomePrivateField div 5;
end;

Der Datentyp Real entspricht in Delphi standardmässig dem Double. Zur Rückwärtskompatibilität kann man ihm mit dem Compilerschalter {$REALCOMPATIBILITY ON} dem Real48 gleichsetzen.

Der Datentyp Integer hängt von der jeweiligen Pascal-Implementation ab. In 16bit-Implementationen (z.B. Turbo Pascal) entsprach er einem SmallInt, in 32bit-Implementationen einem LongInt und in 64bit-Implementationen wird er einem Int64 entsprechen.

Der Datentyp String entspricht standardmäßig einem AnsiString. Mit {$LONGSTRINGS OFF} entspricht er zur Rückwärtskompatibilität einem ShortString.

and array as asm begin case class const constructor destructor dispinterface div do downto else end except exports file finalization finally for function goto if implementation in inherited initialization inline interface is label library mod nil not object of or out packed procedure program property raise record repeat resourcestring set shl shr string then threadvar to try type unit until uses var while with xor

Direktiven sind Symbole die ca. in bestimmten Kontexten reserviert sind, sonst aber als Namen für Variablen, Funktionen, usw. benutzt werden können.

absolute abstract assembler at automated cdecl default deprecated dispip dynamic export far implements index library near nodefault on overload override pascal platform private protected public published read register reintroduce safecall stdcall stored virtual write

• Borland Software Corporation (http://www.borland.com)
• Delphi-PRAXiS (Forum) (http://www.delphipraxis.net)
• Delphi-Forum.de (http://www.delphi-forum.de)
• Free Pascal (http://www.freepascal.org)
• Virtual Pascal (http://www.vpascal.com)
• Torry's Delphi Pages (http://www.torry.net)
• Delphi-Source.de (http://www.delphi-source.de)
• Links zu Delphi (http://www.coderlinks.de/delphi,100,101.html)